// #include <bits/stdc++.h>
// using namespace std;
// extern int Sub(int a,int b);

// class stu
// {
// public:
//     int a;
//     int b;

//     // void print(){
//     //     cout<<"姓名："<<name<<" "<<"年龄"<<age<<endl;
//     // }

// };

// int main()
// {
//     stu s1;
//     scanf("%d%d",&s1.a,&s1.b);

//     printf("a = %d b = %d\n",s1.a,s1.b);
//     printf("%d\n",Sub(s1.a,s1.b));

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// class Person
// {
// public:
//     //公共权限
//     string m_Name;//姓名
// protected:
//     //保护权限
//     string m_Car;//汽车
// private:
//     //私有权限
//     int m_Password;//银行卡密码
// public:
//     void func(){
//         m_Name="张三";
//         m_Car="拖拉机";
//         m_Password=123456;
//     }
// };
// int main()
// {
//     //实例化具体对象
//     Person p1;

//     p1.m_Name="李四";
//     // p1.m_Car="奔驰";
//     // p1.m_Password=123;

//     p1.func();

//    system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// class C1
// {
//     int m_A;//默认是私有权限
// };
// struct C2
// {
//     int m_A;//默认是公共权限
// };
// int main()
// {
//     //struct和class的区别
//     //struct默认权限为公共
//     //class默认权限为私有

//     C1 c1;
//     //c1.m_A=100;////在class里默认权限是私有，因此类外不可以访问

//     C2 c2;
//     c2.m_A=100;//在struct默认的权限为公共，因此可以访问

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// class Person
// {
// public:
//     //设置姓名
//     void setName(string name){
//         m_Name=name;
//     }
//     //获取姓名
//     string getName(){
//         return m_Name;
//     }

//     //获取年龄
//     int getAge(){
//         return m_Age;
//     }
//     //设置年龄（0~150）
//     void setAge(int age){
//         if(age<0||age>150){
//             cout<<"年龄："<<age<<"输入有误，赋值失败"<<endl;
//             return;
//         }
//         m_Age=age;
//     }

//     //设置偶像
//     void getIdol(string idol){
//         m_Idol = idol;
//     }

//     //打印
//     void print(){
//         cout<<"姓名："<<m_Name<<"\n";
//         cout<<"年龄："<<m_Age<<"\n";
//         cout<<"偶像："<<m_Idol<<"\n";
//     }

// private:
//     string m_Name;//姓名    可读可写
//     int m_Age = 18;//年龄    只读
//     string m_Idol = "毛泽东";//偶像    只写
// };
// int main()
// { 
//     Person p;
//     //姓名设置
//     p.setName("张三");
//     cout<<"姓名："<<p.getName()<<endl;

//     //获取年龄
//     p.setAge(200);
//     printf("年龄：%d\n",p.getAge());

//     //p.getIdol("周恩来");

//     p.print();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// class Cube{
// public:
//     //行为
//     //设置长宽高
//     void ckg(int l,int w,int h){
//         m_L=l;
//         m_W=w;
//         m_H=h;
//     }
//     //获取长宽高
//     int C(){
//         return m_L;
//     }
//     int K(){
//         return m_W;
//     }
//     int H(){
//         return m_H;
//     }
//     //获取立方体面积
//     int MJ(){
//         return (m_L*m_W+m_L*m_H+m_H*m_W)*2; 
//     }
//     //获取立方体体积
//     int TJ(){
//         return m_H*m_L*m_W;
//     }
//     //利用局部函数判断两个立方体是否相等
//     bool isSameClass(Cube &c){
//         if(c.C()==C()&&c.K()==K()&&c.H()==H())
//             return true;
//         else
//             return false;
//     }
// private:
//     //属性
//     int m_L;//长
//     int m_W;//宽
//     int m_H;//高

// };
// //利用全局函数判断两个立方体是否相等
// bool isSame(Cube &c1,Cube &c2)
// {
//     if(c1.C()==c2.C()&&c1.K()==c2.K()&&c1.H()==c2.H())
//         return true;
//     else
//         return false;
// }
// int main()
// {
//     //创建立方体对象
//     Cube c1;
//     int l1,w1,g1;
//     printf("请输入C1的长宽高：");
//     scanf("%d%d%d",&l1,&w1,&g1);
//     c1.ckg(l1,w1,g1);

//     Cube c2;
//     printf("请输入C2的长宽高：");
//     scanf("%d%d%d",&l1,&w1,&g1);
//     c2.ckg(l1,w1,g1);

//     //利用全局函数判断
//     if(isSame(c1,c2))
//         cout<<"全局函数判断：c1和c2是相等的！"<<endl;
//     else
//         cout<<"全局函数判断：c1和c2是不相等的！"<<endl;

//     //利用成员函数判断
//     if(c1.isSameClass(c2))
//         cout<<"成员函数判断：c1和c2是相等的！"<<endl;
//     else
//         cout<<"成员函数判断：c1和c2是不相等的！"<<endl;

//     cout<<"c1的面积： "<<c1.MJ()<<"\n";
//     cout<<"c1的体积："<<c1.TJ()<<"\n";
//     cout<<"c2的面积： "<<c2.MJ()<<"\n";
//     cout<<"c2的体积："<<c2.TJ()<<"\n";

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <math.h>
// using namespace std;

// class Circle{
//     //行为
// public:
//     //获取圆心
//     void cir(int x,int y){
//         c1.x = x;
//         c1.y = y;
//     }
//     // //获取半径
//     // void BJ(int br){
//     //     m_r = br;
//     // }
//     //确定两点之间的距离
//     float Circledir(int dir1,int dir2){
//         return sqrt((dir1-c1.x)*(dir1-c1.x)+(dir2-c1.y)*(dir2-c1.y));
//     }

//     //属性
// private:
//     struct Cir{//圆心
//         int x;//x轴坐标
//         int y;//y轴坐标
//     }c1;
//     //int m_r;
// };
// int main()
// {
//     Circle C1;
//     int x,y,r;
//     printf("请输入圆心：");
//     scanf("%d%d",&x,&y);

//     printf("请输入半径：");
//     scanf("%d",&r);
//     C1.cir(x,y);
//     //C1.BJ(r);

//     printf("请输入点坐标：");
//     scanf("%d%d",&x,&y);
//     if(C1.Circledir(x,y) == r)
//         printf("该点在圆上！\n");
//     else{
//         if(C1.Circledir(x,y) > r)
//             printf("该点在圆外！\n");
//         else
//             printf("该点在圆内！\n");
//     }

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <stdio.h>
// using namespace std;
// #include "Point.h"
// #include "Circle.h"
// class Point{//圆心
// public:
//     //设置x
//     void setX(int x){
//         m_X = x;
//     }
//     //获取x
//     int getX(){
//         return m_X;
//     }
//     //设置y
//     void setY(int y){
//         m_Y = y;
//     }
//     //获取y
//     int getY(){
//         return m_Y;
//     }
// private:
//     int m_X;
//     int m_Y;

// };
// class Circle{//圆类
// public:
//     //设置半径
//     void setR(int r){
//         m_R = r;
//     }
//     //获取半径
//     int getR(){
//         return m_R;
//     }
//     //设置圆心
//     void setCenter(Point center){
//         m_Center = center;
//     }
//     //获取圆心
//     Point getCenter(){
//         return m_Center;
//     }

// private:
//     int m_R;//半径
//     Point m_Center;//圆心
//     //在类中可以让另一个类作为本来中的成员
// };
//判断点和圆的关系
// void isInCircle(circle &c,point &p){
//     //计算两点之间距离平方
//     int distance = 
//     (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
//     (c.getCenter().getY() - p.getY())*(c.getCenter().getY() - p.getY());

//     //计算半径的平方
//     int rDistance = c.getR() * c.getR();

//     //判断关系
//     if(distance == rDistance)
//         cout<<"点在圆上"<<endl;
//     else if(distance > rDistance)
//         cout<<"点在圆外"<<endl;
//     else
//         cout<<"点在圆内"<<endl;
// }
// int main()
// {
//     //创建圆
//     circle c;
//     int r,x,y;
//     printf("请输入半径和圆心：");
//     scanf("%d%d%d",&r,&x,&y);
//     c.setR(r);
//     point center;
//     center.setX(x);
//     center.setY(y);
//     c.setCenter(center);

//     //创建点
//     point p;
//     printf("请输入点坐标：");
//     scanf("%d%d",&x,&y);
//     p.setX(x);
//     p.setY(y);

//     //判断关系
//     isInCircle(c,p);

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //对象的初始化和清理
// class Person
// {
// public:
//     //1.1、构造函数:对象的初始化
//     //没有返回值不用写void
//     //函数名与类名相同
//     //构造函数可以有参数，可以发生重载
//     //创建对象的时候，构造函数会自动调用，而且只调用一次
//     Person(){
//         cout<<"Person构造函数的调用"<<endl;
//     }
//     //2、析构函数进行清理操作
//     //没有返回值不写void
//     //函数名和类名相同，在名称前加~
//     //析构函数不可以有参数，不可以发生重载
//     //对象在销毁前，会自动调用析构函数，而且只会调用一次
//     ~Person(){
//         cout<<"Person析构函数的调用"<<endl;
//     }
// };

// //构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
// void test01(){
//     Person p;//在栈上的数据，test01执行完毕后，释放这个对象
// }
// int main()
// {
//     //test01();
//     Person p;

//     system("pause");
//     //在这里有system("pause")使得该函数的运行暂停了，所有只用了构造函数
//     //在这个语句结束后，直接使用析构函数，释放这个对象
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //1.构造函数的分类及调用
// //分类
// //  按照参数分类    无参构造(默认构造)和有参构造
// //  按照类型分类    普通构造、拷贝构造
// class Person
// {
// public:
//     //构造函数
//     Person(){
//         cout<<"Person的无参构造函数调用"<<endl;
//     }
//     Person(int a){
//         age = a;
//         cout<<"Person的有参构造函数调用"<<endl;
//     }
//     //拷贝构造函数
//     Person(const Person &p){
//         //将传入的人身上的所有属性，拷贝到我身上
//         age = p.age;
//         cout<<"Person的拷贝构造函数调用"<<endl;
//     }
//     ~Person(){
//         cout<<"Person的析构函数调用"<<endl;
//     }
//     int age;
// };
// //调用
// void test01(){
//     //1、括号法
//     // Person p1;//默认构造函数调用
//     // Person p2(10);//有参构造函数
//     // Person p3(p2);//拷贝构造函数

//     //注意事项
//     //调用默认构造函数对象，不要加()
//     //因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
//     //Person p1();

//     //cout<<"P2的年龄为："<<p2.age<<endl;
//     //cout<<"p3的年龄为："<<p3.age<<endl;

//     //2、显示法
//     // Person p1;
//     // Person p2 = Person(10);//有参构造
//     // Person p3 = Person(p2);//拷贝构造
    
//     //Person(10);//匿名对象   特点：当前行执行结束后，系统会立即回收掉匿名对象

//     //注意事项2
//     //不要利用拷贝构造函数初始化匿名对象,编译器会认为Person(p3)==Person p3;对象声明重定义
//     //例如：
//     //Person(p3);

//     //3、隐式转换法
//     Person p4 = 10;//相当于写了Person p4 = Person(10);
//     Person p5 = p4;//拷贝构造

// }
// int main()
// {
//     test01();


//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //拷贝构造函数调用时机
// //1、使用一个已经创建完毕的对象来初始化一个新对象
// //2、值传递的方式给函数参数传值
// //3、值方式返回局部对象
// class Person
// {
// public:
//     Person(){
//         cout<<"Person默认构造函数调用"<<endl;
//     }
//     Person(int age){//有参构造函数
//         cout<<"Person有参构造函数调用"<<endl;
//         m_Age = age;
//     }
//     Person(const Person &p){
//         cout<<"Person拷贝构造函数调用"<<endl;
//         m_Age = p.m_Age;
//     }
//     ~Person(){
//         cout<<"Person析构构造函数调用"<<endl;
//     }
//     int m_Age;
// };
// //1、使用一个已经创建完毕的对象来初始化一个新对象
// void test01(){
//     Person p1(20);
//     Person p2(p1);

//     cout<<"P2的年龄为："<<p2.m_Age<<endl;
// }
// //2、值传递的方式给函数参数传值
// void doWork(Person p){

// }
// void test02(){
//     Person p;
//     doWork(p);
// }
// //3、值方式返回局部对象
// Person doWork2(){
//     Person p1;
//     cout<<(int*)&p1<<endl;
//     return p1;
// }
// void test03(){
//     Person p = doWork2();
//     cout<<(int*)&p<<endl;
// }

// int main()
// {
//     //test01();
//     //test02();
//     test03();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //构造函数的调用规则
// //1、创建一个类，C++编译器会给每个类都添加至少3个函数
// //默认构造（空实现）
// //析构函数（空实现）
// //拷贝构造（值拷贝）

// class Person
// {
// public:
//     // Person(){
//     //     cout<<"Person的默认构造函数调用"<<endl;
//     // }
//     // Person(int age){
//     //     cout<<"Person的有参构造函数调用"<<endl;
//     //     m_Age = age;
//     // }
//     Person(const Person &p){
//         cout<<"Person的拷贝构造函数调用"<<endl;
//         m_Age = p.m_Age;
//     }
//     ~Person(){
//         cout<<"Person的析构构造函数调用"<<endl;
//     }
//     int m_Age;
// };
// // void test01(){
// //     Person p;//Person的默认构造函数调用
// //     p.m_Age = 18;

// //     Person p2(p);//Person的拷贝构造函数调用

// //     cout<<"p2的年龄为："<<p2.m_Age<<endl;
// // }

// //如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
// void test02(){
//     Person p;
//     Person p2(p);
//     //cout<<"p2的年龄为："<<p2.m_Age<<endl;
// }
// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //深拷贝与浅拷贝
// class Person{
// public:
//     Person(){
//         cout<<"Person的默认构造函数调用"<<endl;
//     }
//     Person(int age,int height){
//         m_Age = age;
//         m_Height = new int(height);
//         cout<<"Person的有参构造函数调用"<<endl;
//     }
//     Person(const Person &p){//拷贝构造
//         cout<<"Person拷贝构造函数调用"<<endl;
//         m_Age = p.m_Age;
//         //m_Height = p.m_Height;//编译器默认实现就是这行代码

//         //深拷贝操作
//         m_Height = new int(*p.m_Height);
//     }
//     ~Person(){
//         //析构代码，将堆区开辟数据做释放操作
//         if(m_Height != NULL){
//             delete m_Height;
//             m_Height = NULL;
//         }
//         cout<<"Person的析构函数调用"<<endl;
//     }
//     int m_Age;//年龄
//     int *m_Height;//身高
// };
// void test01(){
//     Person p1(18,160);//有参构造函数
//     cout<<"p1的年龄为："<<p1.m_Age<<" 身高为："<<*p1.m_Height<<endl;

//     Person p2(p1);//拷贝构造函数
//     cout<<"p2的年龄为："<<p2.m_Age<<" 身高为："<<*p2.m_Height<<endl;

// }
// int main()
// {
//     test01();

//     system("pause"); 
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //初始化列表
// class Person
// {
// public:
//     // //传统初始化操作
//     // Person(int a,int b,int c){
//     //     m_A = a;
//     //     m_B = b;
//     //     m_C = c;
//     // }

//     //初始化列表初始化属性
//     Person(int a,int b,int c):m_A(a),m_B(b),m_C(c){

//     }

//     int m_A;
//     int m_B;
//     int m_C;

// };
// void test01(){
//     //Person p(10,20,30);
//     int a,b,c;
//     cin>>a>>b>>c;
//     Person p(a,b,c);
//     cout<<"m_A = "<<p.m_A<<endl;
//     cout<<"m_B = "<<p.m_B<<endl;
//     cout<<"m_C = "<<p.m_C <<endl;

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <string>
// using namespace std;

// //类对象作为类成员

// //手机类
// class Phone{
// public:
//     Phone(string pName){
//         cout<<"Phone的构造函数调用"<<endl;
//         m_PName = pName;
//     }
//     ~Phone()
//     {
//         cout<<"Phone析构函数的调用"<<endl;
//     }

//     //手机品牌名称
//     string m_PName;
// }; 
// //人类
// class Person
// {
// public:
//     //Phone m_Phone = pName
//     Person(string name,string pName):m_Name(name),m_Phone(pName)
//     {
//         cout<<"Person构造函数的调用"<<endl;
//     }
//     ~Person()
//     {
//         cout<<"Person析构函数的调用"<<endl;
//     }
//     //姓名
//     string m_Name;
//     //手机
//     Phone m_Phone;

// };
// //当其他类对象作为本类成员，构造时先构造类对象。再构造自身
// //析构顺序与构造顺序相反
// void test01(){
//     Person p("张三","苹果MAX");

//     cout<<p.m_Name<<"拿着："<<p.m_Phone.m_PName<<endl;
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <string>
// using namespace std;
// class Phone
// {
// public:
//     Phone(string name){
//         m_phone = name;
//         cout<<"Phone构造函数调用"<<endl;
//     }
//     ~Phone(){
//         cout<<"Phone析构函数调用"<<endl;
//     }
//     string m_phone;
// };
// class Person
// {
// public:
//     Person(string person,string phone):m_person(person),m_phone(phone)
//     {
//         cout<<"Person构造函数调用"<<endl;
//     }
//     ~Person(){
//         cout<<"Person析构函数调用"<<endl;
//     }

//     string m_person;
//     Phone m_phone;
// };
// void test01(){
//     Person p("张明","小米");

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //静态成员变量
// class Person
// {
// public:
//     //1.所有对象都共享同一份数据
//     //2.编译阶段就分配内存
//     //3.类内声明，类外初始化操作
//     static int m_A;//类内声明

// private:
//     static int m_B;

// };
// int Person::m_A = 100;//类外初始化
// int Person::m_B = 100;

// void test01()
// {
//     Person p;
//     cout<<p.m_A<<endl;

//     Person p2;
//     p.m_A = 200;
//     cout<<p.m_A<<endl;

// }
// void test02()
// {
//     //静态成员变量不属于某个对象上，所有对象都共享同一份数据
//     //因此静态成员变量有两种访问方式

//     //1、通过对象进行访问
//     Person p;
//     cout<<p.m_A<<endl;
//     //2、通过类名进行访问
//     cout<<Person::m_A<<endl;

//     //cout<<Person::m_B<<endl;//类外访问不到静态成员变量

// }

// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //静态成员函数
// //所有对象共享同一个函数
// //静态成员函数只能访问静态成员变量
// class Person
// {
// public:
//     //静态成员函数
//     static void func(){
//         m_A = 100;//静态成员函数可以访问静态成员变量
//         //m_B = 200;//静态成员函数不可以访问非静态成员：无法区分到底是哪个对象的m_B属性
//         cout<<"static void func调用"<<endl;
//     }

//     static int m_A;//静态成员变量
//     int m_B;//非静态成员变量

//     //静态成员函数也有访问权限
// private:
//     static void func2(){
//         cout<<"static void func2调用"<<endl;
//     }
// };
// int Person::m_A = 0;

// void test01(){
//     //有两种访问方式
//     //1.通过对象访问
//     Person p;
//     p.func();

//     //2.通过类名访问
//     Person::func();

//     //Person::func2();//类外访问不到私有静态成员函数

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //成员变量和成员函数分开存储的
// class Person
// {
//     int m_A;//非静态成员变量：属于类的对象上
//     static int m_B;//静态成员变量：不属于类的对象上
//     void func(){}//非静态成员函数：不属于类的对象上
//     static void func(){};//静态成员函数：不属于类的对象上
// };
// int Person::m_B = 0;

// void test01(){
//     Person p1,p2;

//     //空对象占用内存空间为：1
//     //C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
//     //每个空对象也应该有一个独一无二的内存地址
//     cout<<"size of p = "<<sizeof(p1)<<endl;
//     cout<<"size of p = "<<sizeof(p2)<<endl;
// }
// void test02(){
//     Person p1;
//     cout<<"size of p = "<<sizeof(p1)<<endl;
// }
// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// class Person
// {
// public:
//     Person(int age){//有参构造函数
//         //this指针指向被调用的成员函数所属的对象
//         this->age = age;
//     }
//     Person& PersonAddAge(Person &p){
//         this->age += p.age;
//         //this指向p2的指针，而*this指向的是p2这个对象本体
//         return *this;
//     }
//     int age;

// };

// //1、解决名称冲突
// void test01(){
//     Person p1(18);
//     cout<<"p1的年龄为："<<p1.age<<endl;
// }

// //2、返回对象本身用*this
// void test02(){
//     Person p1(10);
//     Person p2(10);

//     //链式编程思想
//     p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
//     cout<<"p1的年龄为:"<<p1.age<<endl;
//     cout<<"p2的年龄为:"<<p2.age<<endl;

// }

// int main()
// {
//     //test01();
//     test02();
    
//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// class Person{
// public:
//     void showClassName(){
//         cout << "this is Person class" << endl;
//     }
//     void showPersonAge(){
//         //报错原因：传入的指针是为NULL
//         if(this==NULL)return;
//         cout << "age = "<< m_Age << endl;
//     }
//     int m_Age = 50;
// };
// void test01(){
//     // Person p1;
//     // Person *p = &p1;
//     Person *p = NULL;
//     p->showClassName();
//     p->showPersonAge();
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //常函数
// class Person{
// public:
//     Person(){

//     }
//     //this指针的本质是指针常量，指针的指向是不可以修改的
//     //const Person *const this;
//     //在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
//     void showPerson()const{
//         this->m_B = 100;
//         //this->m_A = 100;
//         //this = NULL;//this指针不可以修改指针的指向的
//     }
//     void func(){

//     }
//     int m_A;
//     mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值,加关键字mutable
// };
// //常对象
// void test02(){
//     const Person p;
//     //p.m_A = 100;
//     p.m_B = 100;//m_B是特殊值，在常对象下也可以修改

//     //常对象只能调用常函数
//     p.showPerson();
//     //p.func();
// }
// int main()
// {
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <string>
// using namespace std;
// //建筑物类
// class Building
// {
//     //goodGay全局函数是Building好朋友，可以访问Building中私有成员
//     friend void goodGay(Building *building);
// public:
//     string m_SittingRoom;//客厅
//     Building(){
//         m_SittingRoom = "客厅";
//         m_BedRoom = "卧室";
//     }
// private:
//     string m_BedRoom;//卧室

// };
// //全局函数
// void goodGay(Building *building){
//     cout<<"好基友全局函数正在访问："<<building->m_SittingRoom<<endl;

//     cout<<"好基友全局函数正在访问："<<building->m_BedRoom<<endl;
// }
// void test01(){
//     Building building;
//     goodGay(&building);

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //类做友元
// class Building;
// class GoodGay{
// public:
//     GoodGay();
//     void visit();//参观函数访问Building中的属性
//     Building *building;
// };
// class Building
// {
//     //GoodGay类是本类的好朋友，可以访问本类中私有成员
//     friend class GoodGay;
// public:
//     Building();
//     string m_SittingRoom;//客厅
// private:
//     string m_BedRoom;//卧室
// };

// //类外写成员构造函数
// Building::Building(){
//     m_SittingRoom = "客厅";
//     m_BedRoom = "卧室";
// }
// GoodGay::GoodGay(){
//     //创建建筑物对象
//     building = new Building;
//     //利用new创建的数据，会返回该数据对应的类型的指针
// }
// void GoodGay::visit(){
//     cout<<"好基友类正在访问："<<building->m_SittingRoom<<endl;

//     cout<<"好基友类正在访问："<<building->m_BedRoom<<endl;
// }
// void test01(){
//     GoodGay g;
//     g.visit();

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// class Building;
// class GoodGay{
// public:
//     GoodGay();
//     void visit();   //让visit函数可以访问Building中私有成员
//     void visit2();  //让visit函数不可以访问Building中私有成员

//     Building *building;
// };
// class Building{
//     //告诉编译器，GoodGay类下的visit成员函数作为本类的好朋友
//     friend void GoodGay::visit();
// public:
//     Building();
// public:
//     string m_SittingRoom;//客厅
// private:
//     string m_BedRoom;//卧室

// };
// //类外实现成员函数
// Building::Building(){
//     m_SittingRoom = "客厅";
//     m_BedRoom = "卧室";
// }
// GoodGay::GoodGay(){
//     building = new Building;
// }
// void GoodGay::visit(){
//     cout<<"visit函数正在访问："<<building->m_SittingRoom<<endl;

//     cout<<"visit函数正在访问："<<building->m_BedRoom<<endl;
// }
// void GoodGay::visit2(){
//     cout<<"visit函数正在访问："<<building->m_SittingRoom<<endl;

//     //cout<<"visit函数正在访问："<<building->m_BedRoom<<endl;
// }
// void test01(){
//     GoodGay g;
//     g.visit();
//     g.visit2();
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //加号运算符重载
// class Person
// {
// public:
//     int m_A;
//     int m_B;

//     //1、成员函数重载+号
//     // Person operator+(Person &p){
//     //     Person temp;
//     //     temp.m_A = m_A + p.m_A;
//     //     temp.m_B = m_B + p.m_B;

//     //     return temp;
//     // }
// };
// //2、全局函数重载+号
// Person operator-(Person &p1,Person &p2){
//     Person temp;
//     temp.m_A = p1.m_A - p2.m_A;
//     temp.m_B = p1.m_B - p2.m_B;

//     return temp;
// }
// Person operator-(Person &p1,int num){
//     Person temp;
//     temp.m_A = p1.m_A - num;
//     temp.m_B = p1.m_B - num;

//     return temp;
// }
// int main()
// {
//     Person p1,p2;
//     p1.m_A = 10;
//     p1.m_B = 50;

//     p2.m_A = 10;
//     p2.m_B = 20;

//     //成员函数重载本质调用
//     //Person p3 = p1.operator+(p2);

//     //全局函数重载本质调用
//     //Person p3 = operator+(p1,p2);

//     Person p3 = p1 - p2;
    
//     //运算符重载也可以发生函数重载
//     Person p4 = p1 - 100;

//     cout << "p3.m_A = " << p3.m_A << endl;
//     cout << "p3.m_B = " << p3.m_B << endl;

//     cout << "p4.m_B = " << p4.m_A << endl;
//     cout << "p4.m_B = " << p4.m_B << endl;

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //左移运算符重载
// class Person
// {
//     friend ostream& operator<<(ostream &out,Person &p);
// public:
//     Person(int a,int b){
//         m_A = a;
//         m_B = b;
//     }
// private:
//     int m_A;
//     int m_B;

//     // 利用成员函数重载左移运算符
//     // 不会利用成员函数重载<<运算符因为无法实现cout在左侧
//     // void operator<<(){}

// };

// //只能利用全局函数重载左移运算符
// ostream& operator<<(ostream &out,Person &p){//本质 operator<<(cout,p),简化cout<<p
//     out << "m_A = " << p.m_A << endl << "m_B = " << p.m_B << endl;
//     return out;
//     //需要有cout的返回类型
//     //因为cout是链式编程思想，如果不返回，cout只能输出一个
//     //cout是标准输出流对象（ostream）
// }
// void test01(){
//     Person p(10,10);
    
//     cout << p << "hello world" << endl;
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //重载递增运算符
// //自定义整型
// class MyInteger
// {
//     friend ostream& operator<<(ostream& cout,MyInteger myint);
// public:
//     MyInteger(){
//         m_Num = 0;
//     }
//     //重置前置++运算符，返回引用是为了一直对一个数据进行递增操作
//     MyInteger& operator++(){
//         //先进行++运算
//         ++m_Num;

//         //再将自身做返回
//         return *this;
//     }
//     //重置前置--运算符
//     MyInteger& operator--(){
//         //先进行--运算
//         --m_Num;

//         //再将自身做返回
//         return *this;
//     }

//     //重置后置++运算符
//     //void operator++(int)  int代表参数，可以用于区分前置和后置递增
//     MyInteger operator++(int){
//         //先 记录当时结果
//         MyInteger temp = *this;

//         //后 递增
//         m_Num++;

//         //最后将记录结果做返回
//         return temp;      //不能返回局部变量做引用  
//     }

//     //重置后置--运算符
//     MyInteger operator--(int){
//         // 记录当时结果
//         MyInteger temp = *this;

//         //后 递增
//         m_Num--;

//         //最后将记录结果做返回
//         return temp;
//     }

// private:
//     int m_Num;
// };
// //重载<<运算符
// ostream& operator<<(ostream& cout,MyInteger myint){
//     cout << myint.m_Num;
//     return cout;
// }
// void test01(){
//     MyInteger myint;
    
//     cout << ++(++myint) << endl;
//     cout << myint << endl;
// }
// void test02(){
//     MyInteger myint;

//     cout << myint++ <<endl;
//     cout<< myint << endl;

// }
// void test03(){
//     MyInteger myint;

//     cout << myint <<endl;
//     cout << --myint << endl;
// }
// void test04(){
//     MyInteger myint;

//     cout << myint-- << endl;
//     cout << myint << endl;
// }
// int main()
// {
//     //test01();
//     //test02();
//     //test03();
//     test04();


//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //赋值运算符重载
// class Person
// {
// public:
//     Person(int age){
//         m_Age = new int(age);
//     }
//     ~Person(){
//         if(m_Age != NULL){
//             delete m_Age;
//             m_Age = NULL;
//         }
//     }

//     //重载赋值运算符
//     Person& operator=(Person &p){
//         //编译器提供浅拷贝
//         //m_Age = p.m_Age;

//         //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
//         if(m_Age != NULL){
//             delete m_Age;
//             m_Age = NULL;
//         }

//         //深拷贝
//         m_Age = new int(*p.m_Age);

//         //返回对象本身
//         return *this;
//     }

//     int *m_Age;
// };
// void test01(){
//     Person p1(18);
//     Person p2(20);
//     Person p3(30);

//     p3 = p2 = p1;

//     cout << "p1的年龄为：" << *p1.m_Age << endl;
//     cout << "p2的年龄为：" << *p2.m_Age << endl;
//     cout << "p3的年龄为：" << *p3.m_Age << endl;

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //重载关系运算符
// class Person{
// public:
//     Person(string num,int age):m_Name(num),m_Age(age){}
//     bool operator==(Person &p){
//         if(p.m_Age == this->m_Age && p.m_Name == this->m_Name){
//             return true;
//         }
//         return false;
//     }
//     bool operator!=(Person &p){
//         if(p.m_Age == this->m_Age && p.m_Name == this->m_Name){
//             return false;
//         }
//         return true;
//     }

// private:
//     string m_Name;
//     int m_Age;
// };
// void test01(){
//     Person p1("zhangsan",18);
//     Person p2("zhangsan",18);

//     // if(p1 == p2){
//     //     cout << "p1 和 p2 是相等的！" << endl;
//     // }
//     // else{
//     //     cout << "p1 和 p2 是不相等的！" << endl;
//     // }

//     if(p1 != p2){
//         cout << "p1 和 p2 是不相等的！" << endl;
//     }
//     else{
//         cout << "p1 和 p2 是相等的！" << endl;
//     }
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //函数调用运算符重载
// //打印输出类
// class MyPrint{
// public:
//     //重载函数调用运算符
//     void operator()(string test){
//         cout << test << endl;
//     }
// };
// void MyPrint02(string test){
//     cout << test << endl;
// }
// void test01(){
//     MyPrint myPrint;

//     myPrint("hello world");//由于使用起来非常类似于函数调用，因此被称为仿函数
//     MyPrint02("hello world");
// }

// //仿函数非常灵活，没有固定的写法
// //加法类
// class MyAdd
// {
// public:
//     int operator()(int num1,int num2){
//         return num1 + num2;
//     }
// };
// void test02(){
//     MyAdd myadd;
//     cout << myadd(55,10) << endl;

//     //匿名函数对象：当前行执行完，立即被释放
//     cout << MyAdd()(100,100) << endl;
// }
// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //继承
// //公共页面
// class BasePage{
// public:
//     void header(){
//         cout<<"首页、公开课、登录、注册……（公共头部）"<<endl;
//     }
//     void footer(){
//         cout<<"帮助中心、交流合作、站内地图……（公共底部）"<<endl;
//     }
//     void left(){
//         cout<<"Java、Python、C++……（公共分类列表）"<<endl;
//     }
// };
// //继承的好处：减少重复代码
// //语法：class 子类：继承方式 父类
// //子类也称为派生类
// //父类也称为基类
// //Java页面
// class Java:public BasePage
// {
// public:
//     void content(){
//         cout<<"Java学科视频"<<endl;
//     }
// };
// //Python页面
// class Python:public BasePage
// {
// public:
//     void content(){
//         cout<<"Python学科视频"<<endl;
//     }
// };
// //C++页面
// class Cpp:public BasePage
// {
// public:
//     void content(){
//         cout<<"Cpp学科视频"<<endl;
//     }
// };
// void test01(){
//     cout << "Java下载视频页面如下：" << endl;
//     Java ja;
//     ja.header();
//     ja.footer();
//     ja.left();
//     ja.content();

//     cout << "-----------------------" << endl;
//     cout << "Python下载视频页面如下：" << endl;
//     Python py;
//     py.header();
//     py.footer();
//     py.left();
//     py.content();

//     cout << "-----------------------" << endl;
//     cout << "Cpp下载视频页面如下：" << endl;
//     Cpp cpp;
//     cpp.header();
//     cpp.footer();
//     cpp.left();
//     cpp.content();

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //继承方式
// class Base{
// public:
//     int m_A;
// protected:
//     int m_B;
// private:
//     int m_C;
// };
// //公共继承
// class Son1:public Base
// {
// public:
//     void func(){
//         m_A = 10;//父类中的公共权限到子类中依然是公共权限
//         m_B = 10;//父类中的保护权限到子类中依然是保护权限
//         //m_C = 10;//父类中的私有权限成员子类访问不到
//     }
// };
// //保护继承
// class Son2:protected Base
// {
// public:
//     void func(){
//         m_A = 10;//父类中公共成员，到子类中变为保护权限
//         m_B = 10;//父类中保护成员，到子类中变为保护权限
//         //m_C = 10;//父类中的私有成员，子类访问不到
//     }
// };
// //私有继承
// class Son3:private Base
// {
// public:
//     void func(){
//         m_A = 10;//父类中公共成员到子类中变为私有成员
//         m_B = 10;//父类中保护成员到子类中变为私有成员
//         //m_C = 10;//父类中私有成员，子类访问不到
//     }
// };
// class GrandSon3:public Son3
// {
// public:
//     void func(){
//         //m_A = 1000;//到了Son3中，m_A变为私有，即使是儿子，也是访问不到
//         //m_B = 1000;//到了Son3中，m_B变为私有，即使是儿子，也是访问不到
//     }
// };
// void test01(){
//     Son1 s1;
//     s1.m_A = 100;
//     //s1.m_B = 100;//到了Son1中，m_B是保护权限，类外访问不到

//     Son2 s2;
//     //s2.m_A = 10;//在Son2中，m_A变为保护权限，因此类外访问不到
//     //s2.m_B = 10;//在Son2中，m_B保护权限不可以访问

//     Son3 s3;
//     //s3.m_A = 100;//到Son3中变为私有成员，类外访问不到
//     //s3.m_B = 100;//到Son3中变为私有成员，类外访问不到

// }
// int main()
// {

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //继承中的对象模型
// class Base
// {
// public:
//     int m_A;
// protected:
//     int m_B;
// private:
//     int m_C;
// };
// class Son:public Base{
// public:
//     int m_D;
// };
// void test01(){

//     cout << "size of Son = " << sizeof(Son) << endl;
//     //父类中的所有非静态成员属性都会被子类继承下去
//     //父类中的私有成员属性
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //继承中的构造和析构顺序
// class Base
// {
// public:
//     Base(){
//         cout << "Base构造函数！" << endl;
//     }
//     ~Base(){
//         cout << "Base的析构函数！" << endl;
//     }
// };
// class Son:public Base
// {
// public:
//     Son(){
//         cout << "Son构造函数！" << endl;
//     }
//     ~Son(){
//         cout << "Son析构函数！" << endl;
//     }
// };
// void test01(){
//     //Base b;

//     //继承中的构造和析构顺序如下：
//     //先构造父亲，再构造子类，析构的顺序与构造的顺序相反
//     Son s1;

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //继承中同名成员处理
// class Base
// {
// public:
//     Base()
//     {
//         m_A = 100;
//     }
//     void func(){
//         cout << "Base - func()调用"<< endl;
//     }
//     void func(int a){
//         cout << "Base - func(int a)调用"<< endl;
//     }
//     int m_A;
// };
// class Son:public Base
// {
// public:
//     Son(){
//         m_A = 200;
//     }
//     void func(){
//         cout << "Son - func()调用"<< endl;
//     }
//     int m_A;
// };
// //同名成员属性处理
// void test01(){
//     Son s;
//     cout << "Son 下的 m_A = " << s.m_A << endl;

//     //如果通过子类对象访问到父类中同名成员，需要加作用域
//     cout << "Base 下的 m_A = " << s.Base::m_A << endl;
// }
// //同名函数属性处理
// void test02(){
//     Son s;

//     s.func();//直接调用 调用是子类中的同名成员
    
//     //如何调用到父类中同名成员函数：加作用域
//     s.Base::func();

//     //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
//     //如果想访问到父类中被隐藏的同名成员函数，需要加作用域
//     s.Base::func(100);

// }
// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// //继承中的同名静态成员处理方式
// class Base
// {
// public:
//     static int m_A;
//     static void func(){
//         cout<<"Base - static void func()"<<endl;
//     }

// };
// int Base::m_A = 100;

// class Son:public Base
// {
// public:
//     static int m_A;
//     static void func(){
//         cout<<"Son - static void func()"<<endl;
//     }
// };
// int Son::m_A = 200;

// //同名静态成员属性
// void test01(){
//     //通过对象访问
//     cout<<"通过对象访问："<<endl;
//     Son s;
//     cout << "Son 下 m_A = " << s.m_A << endl;
//     cout << "Base 下 m_A = " << s.Base::m_A << endl;

//     //通过类名访问
//     cout<<"通过类名访问："<<endl;
//     cout<<"Son下的m_A = "<<Son::m_A<<endl;
//     cout<<"Base下的m_A = "<<Son::Base::m_A<<endl;
//     //第一个::代表通过类名方式访问，第二个::代表访问父类作用域下
// }
// //同名静态成员函数
// void test02(){
//     //通过对象访问
//     cout<<"通过对象访问："<<endl;
//     Son s;
//     s.func();
//     s.Base::func();

//     //通过类名访问
//     cout<<"通过类名访问："<<endl;
//     Son::func();
//     Son::Base::func();
// }
// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //多继承语法
// class Base1
// {
// public:
//     Base1()
//     {
//         m_A = 100;
//     }
//     int m_A;
// };
// class Base2
// {
// public:
//     Base2()
//     {
//         m_A = 200;
//     }
//     int m_A;
// };
// //子类需要继承Base1和Base2
// //语法：class 子类：继承方式 父类1，继承方式 父类2
// class Son:public Base1,public Base2
// {
// public:
//     Son()
//     {
//         m_C = 300;
//         m_D = 400;
//     }
//     int m_C;
//     int m_D;
// };
// void test01()
// {
//     Son s;
//     cout << "sizeof Son = " << sizeof(s) << endl;

//     //当父类中出现同名成员，需要加作用域区分
//     cout << "Base1::m_A = " << s.Base1::m_A << endl;
//     cout << "Base2::m_B = " << s.Base2::m_A << endl;
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //动物类
// class Animal
// {
// public:
//     int m_Age;
// };

// //利用虚继承，解决菱形继承的问题
// //继承之前，加上关键字virtual变为虚继承
// //Animal类称为虚基类
// //羊类
// class Sheep:virtual public Animal{};

// //驼类
// class Tuo:virtual public Animal{};

// //羊驼类
// class SheepTuo:public Sheep,public Tuo{};

// void test01(){
//     SheepTuo st;

//     st.Sheep::m_Age = 18;
//     st.Tuo::m_Age = 20;

//     //当菱形继承，两个父类拥有相同数据，需要加以作用域区分
//     cout<<"st.Sheep::m_Age = "<<st.Sheep::m_Age<<endl;
//     cout<<"st.Tuo::m_Age = "<<st.Tuo::m_Age<<endl;
//     //cout << "st.m_Age = " << st.m_Age << endl; 
//     cout << sizeof(st) << endl;
//     //这份数据我们知道，只要有一份就可以,菱形继承导致数据有两份，资源浪费
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //多态
// //动物类
// class Animal
// {
// public:
//     //虚函数
//     virtual void speak(){
//         cout<<"动物在说话"<<endl;
//     }
// };
// //猫类
// class Cat:public Animal
// {
// public:
//     //重写  函数返回值类型  函数名 参数列表 完全相同
//     void speak(){
//         cout<<"小猫在说话"<<endl;
//     }
// };
// //狗类
// class Dog:public Animal
// {
// public:
//     void speak(){
//         cout << "小狗在说话" << endl;
//     }
// };

// //执行说话的函数
// //地址早绑定，在编译阶段确定函数地址
// //如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

// //动态多态满足条件：
// //1、有继承关系
// //2、子类重写父类的虚函数

// //动态多态使用
// //父类的指针或者引用 指向子类对象

// void doSpeak(Animal &animal)    //Animal &animal = cat;
// {
//     animal.speak();
// }
// void test01(){
//     Cat cat;
//     Dog dog;
//     Animal animal;
//     doSpeak(cat);
//     doSpeak(dog);
//     doSpeak(animal);

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <string.h>

// using namespace std;

// //计算器普通写法
// class Calculator
// {
// public:
//     int getResult(string oper)
//     {
//         if(oper == "+")
//             return m_Num1 + m_Num2;
//         else if(oper == "-")
//             return m_Num1 - m_Num2;
//         else if(oper == "*")
//             return m_Num1 * m_Num2;
//         else 
//             return 0;
//         //如果想扩展新的功能，需要修改源码
//         //在真实开发中，提倡开闭原则
//         //开闭原则：对扩展进行开放，对修改进行关闭
//     } 

//     int m_Num1;//操作数1
//     int m_Num2;//操作数2
// };
// //利用多态实现计算器
// //实现计算器抽象类
// //1、组织结构清晰
// //2、可读性强
// //3、对于前期和后期扩展以及维护性高

// //实现计算器抽象类
// class AbstractCalculator
// {
// public:
//     virtual int getResult(){
//         return 0;
//     }

//     int m_Num1;
//     int m_Num2;
// };
// //加法计算器类
// class AddCalculator:public AbstractCalculator
// {
// public:
//     int getResult(){
//         return m_Num1 + m_Num2;
//     }
// };
// //减法计算器类
// class SubCalculator:public AbstractCalculator
// {
// public:
//     int getResult(){
//         return m_Num1 - m_Num2;
//     }
// };
// //乘法计算器类
// class MulCalculator:public AbstractCalculator
// {
// public:
//     int getResult(){
//         return m_Num1 * m_Num2;
//     }
// };
// void test01(){
//     //创建计算器对象
//     Calculator c1;
//     c1.m_Num1 = 10;
//     c1.m_Num2 = 10;

//     cout << c1.m_Num1 << " + " << c1.m_Num2 << " = " << c1.getResult("+") << endl;
//     cout << c1.m_Num1 << " - " << c1.m_Num2 << " = " << c1.getResult("-") << endl;
//     cout << c1.m_Num1 << " * " << c1.m_Num2 << " = " << c1.getResult("*") << endl;
// }
// int oper(AbstractCalculator &c){
//     c.m_Num1 = 20;
//     c.m_Num2 = 5;
//     return c.getResult();
// }
// void test02(){
//     //多态使用条件
//     //父类指针或者引用指向子类对象

//     // //使用父类引用指向子类对象
//     // AddCalculator c1;
//     // SubCalculator c2;
//     // MulCalculator c3;
//     // AbstractCalculator c;

//     // cout << c1.m_Num1 << " + " << c1.m_Num2 << " = " << oper(c1) << endl;
//     // cout << c1.m_Num1 << " - " << c1.m_Num2 << " = " << oper(c2) << endl;
//     // cout << c1.m_Num1 << " * " << c1.m_Num2 << " = " << oper(c3) << endl;

//     //使用父类指针指向子类对象
//     //加法运算
//     AbstractCalculator *abc = new AddCalculator;
//     abc->m_Num1 = 20;
//     abc->m_Num2 = 30;
//     cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
//     //用完后记得释放
//     delete abc;

//     //减法运算
//     abc = new SubCalculator;
//     abc->m_Num1 = 100;
//     abc->m_Num2 = 200;
//     cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;

//     //乘法运算
//     abc = new MulCalculator;
//     abc->m_Num1 = 100;
//     abc->m_Num2 = 5;
//     cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;

// }
// int main()
// {
//     //test01();
//     test02();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //纯虚函数和抽象类
// class Base
// {
// public:
//     //纯虚函数
//     //只要有一个纯虚函数，这个类称为抽象类
//     //抽象类特点
//     //1、无法实例化对象
//     //2、抽象类的子类，必须要重写父类中的纯虚函数，否则也属于抽象类
//     virtual void func() = 0;
// };
// class Son:public Base
// {
// public:
//     void func(){
//         cout << "子类函数的调用" << endl;
//     }
// };
// void test01(){
//     //Base b;//抽象类无法实例化对象
//     //new Base;//抽象类无法实例化对象
//     Son s1;//子类必须重写父类中的纯虚函数，否则无法实例化对象
//     s1.func();

//     Base *base = new Son;
//     base->func();

// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //多态案例2 制作饮品
// class AbstractDrinking
// {
// public:
//     //煮水
//     virtual void Boil() = 0;

//     //冲泡
//     virtual void Brew() = 0;

//     //倒入杯中
//     virtual void PourInCuo() = 0;

//     //加入辅料
//     virtual void PutSomething() = 0;

//     //制作饮品
//     void markDrink(){
//         Boil();
//         Brew();
//         PourInCuo();
//         PutSomething();
//     }
// };
// //制作咖啡
// class Coffee:public AbstractDrinking
// {
// public:
//     //煮水
//     virtual void Boil(){
//         cout << "煮农夫山泉" << endl;
//     }

//     //冲泡
//     virtual void Brew(){
//         cout << "冲泡咖啡" << endl;
//     }

//     //倒入杯中
//     virtual void PourInCuo(){
//         cout << "倒入杯中" << endl;
//     }

//     //加入辅料
//     virtual void PutSomething(){
//         cout << "加入糖和牛奶" << endl;
//     }
// };

// //制作茶叶
// class Tea:public AbstractDrinking
// {
// public:
//     //煮水
//     virtual void Boil(){
//         cout << "煮矿泉水" << endl;
//     }

//     //冲泡
//     virtual void Brew(){
//         cout << "冲泡茶叶" << endl;
//     }

//     //倒入杯中
//     virtual void PourInCuo(){
//         cout << "倒入杯中" << endl;
//     }

//     //加入辅料
//     virtual void PutSomething(){
//         cout << "加入枸杞" << endl;
//     }
// };
// //制作函数
// void doWork(AbstractDrinking *abs){
//     abs->markDrink();
//     delete abs;
// }
// void test01(){
//     //制作咖啡
//     doWork(new Coffee);

//     cout << "----------------" << endl;

//     //制作茶叶
//     doWork(new Tea);
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <string>

// using namespace std;

// //虚析构和纯虚析构
// class Animal
// {
// public:
//     Animal(){
//         cout << "Animal构造函数调用" << endl;
//     }
//     //利用虚析构可以解决父类指针释放子类对象时，不干净的问题
//     // virtual ~Animal(){
//     //     cout << "Animal虚析构函数调用" << endl;
//     // }
    
//     //纯虚析构 需要声明也需要实现
//     //有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
//     virtual ~Animal() = 0;
//     //纯虚函数
//     virtual void speak() = 0;
// };
// Animal::~Animal(){
//     cout << "Animal纯虚析构函数调用" << endl;
// }
// class Cat:public Animal
// {
// public:
//     Cat(string name){
//         m_Name = new string(name);
//         cout << "Cat构造函数调用" << endl;
//     }
//     virtual ~Cat(){
//         if(m_Name != NULL){
//             cout << "Cat析构函数调用" << endl;
//             delete m_Name;
//             m_Name = NULL;
//         }
//     }
//     virtual void speak(){
//         cout << *m_Name << "小猫在说话" << endl;
//     }
//     string *m_Name;
// };
// void test01(){
//     Animal *animal = new Cat("Tom");
//     animal->speak();
//     delete animal;
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// //抽象出每个零件的类
// //抽象CPU类
// class CPU
// {
// public:
//     //抽象计算函数
//     virtual void calculate() = 0;
// };
// //抽象显卡类
// class VideoCard
// {
// public:
//     //抽象显示函数
//     virtual void display() = 0;
// };
// //抽象内存条类
// class Memory
// {
// public:
//     //抽象的存储函数
//     virtual void storage() = 0;
// };

// //电脑类
// class Computer
// {
// public:
//     Computer(CPU *cpu,VideoCard *vc,Memory *mem){
//         m_cpu = cpu;
//         m_vc = vc;
//         m_mem = mem;
//     }
//     //提供工作的函数
//     void work(){
//         //让零件工作起来，调用接口
//         m_cpu->calculate();
//         m_vc->display();
//         m_mem->storage();
//     }
//     //提供析构函数，释放3个电脑零件
//     ~Computer(){
//         //释放CPU零件
//         if(m_cpu != NULL){
//             delete m_cpu;
//             m_cpu = NULL;
//         }
//         //释放显卡零件
//         if(m_vc != NULL){
//             delete m_vc;
//             m_vc = NULL;
//         }
//         //释放内存条零件
//         if(m_mem != NULL){
//             delete m_mem;
//             m_mem = NULL;
//         }        
//     }
// private:
//     CPU *m_cpu;       //CPU的零件指针
//     VideoCard *m_vc;  //显卡零件指针
//     Memory *m_mem;    //内存条零件指针
// };
// //具体厂商
// //Intel厂商
// class IntelCPU:public CPU
// {
// public:
//     virtual void calculate(){
//         cout << "Intel的CPU开始计算了!" << endl;
//     }
// };
// class IntelVideoCard:public VideoCard
// {
// public:
//     virtual void display(){
//         cout << "Intel的显卡开始显示了!" << endl;
//     }
// };
// class IntelMemory:public Memory
// {
// public:
//     virtual void storage(){
//         cout << "Intel的内存条开始存储了!" << endl;
//     }
// };
// //Lenovo厂商
// class LenovoCPU:public CPU
// {
// public:
//     virtual void calculate(){
//         cout << "Lenovo的CPU开始计算了!" << endl;
//     }
// };
// class LenovoVideoCard:public VideoCard
// {
// public:
//     virtual void display(){
//         cout << "Lenovo的显卡开始显示了!" << endl;
//     }
// };
// class LenovoMemory:public Memory
// {
// public:
//     virtual void storage(){
//         cout << "Lenovo的内存条开始存储了!" << endl;
//     }
// };

// void test01(){
//     //第一台电脑零件
//     CPU* intelCPU = new IntelCPU;
//     VideoCard* intelVideoCard = new IntelVideoCard;
//     Memory* intelMem = new IntelMemory;

//     cout << "第一台电脑开始工作" << endl;
//     //创建第一台电脑
//     Computer *computer1 = new Computer(intelCPU,intelVideoCard,intelMem);
//     computer1->work();
//     delete computer1;

//     cout << "---------------" << endl;
//     cout << "第二台电脑开始工作" << endl;
//     //第二台电脑组装
//     Computer *computer2 = new Computer(new LenovoCPU,new LenovoVideoCard,new LenovoMemory);
//     computer2->work();
//     delete computer2;

//     cout << "---------------" << endl;
//     cout << "第三台电脑开始工作" << endl;
//     //第三台电脑组装
//     Computer *computer3 = new Computer(new IntelCPU,new LenovoVideoCard,new LenovoMemory);
//     computer3->work();
//     delete computer3;
// }
// int main()
// {
//     test01();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// int main()
// {
//     system("cmd");
//     return 0;
// }